@copilot

Epic #69: Improve Quality of Java Code Generator

Context

The file scripts/codegen/java.ts is a TypeScript code generator that reads JSON Schema files from the @github/copilot npm dependency and emits Java source files under src/generated/java/. Its purpose is to replace hand-written Java classes in src/main/java/com/github/copilot/sdk/events/ and src/main/java/com/github/copilot/sdk/json/ with auto-generated equivalents.

The current generator produces Java code that is significantly less idiomatic than the hand-written classes it is meant to replace. This prompt describes the required improvements.

Reference files

Before making any changes, read and understand these files:

• scripts/codegen/java.ts — the generator to modify
• src/main/java/com/github/copilot/sdk/events/AbstractSessionEvent.java — the hand-written sealed event hierarchy (the gold standard)
• src/main/java/com/github/copilot/sdk/events/AssistantMessageEvent.java — example of record-based data payload inside a final event class
• src/main/java/com/github/copilot/sdk/events/SessionIdleEvent.java — minimal event with empty record data
• src/main/java/com/github/copilot/sdk/events/UnknownSessionEvent.java — forward-compatibility fallback
• src/main/java/com/github/copilot/sdk/events/SessionEventParser.java — manual type-map-based deserialization
• src/main/java/com/github/copilot/sdk/json/ToolDefinition.java — top-level record DTO
• src/main/java/com/github/copilot/sdk/json/Attachment.java — top-level record DTO
• src/main/java/com/github/copilot/sdk/json/SessionConfig.java — mutable config class with fluent setters
• src/main/java/com/github/copilot/sdk/json/ModelInfo.java — mutable bean with fluent setters
• src/main/java/com/github/copilot/sdk/json/PermissionRequestResultKind.java — extensible enum pattern (string-backed value type with static constants and @JsonCreator)
• src/main/java/com/github/copilot/sdk/json/ElicitationResultAction.java — classic enum with string backing value

Also read .github/copilot-instructions.md for project conventions.

Requirements

1. Use sealed class for the session event hierarchy

The generated SessionEvent.java base class must be declared as:

public abstract sealed class SessionEvent permits
    AssistantMessageEvent, SessionIdleEvent, ...
    UnknownSessionEvent {

The generator must collect all variant class names and emit them in the permits clause. UnknownSessionEvent must always be the last entry.

The hand-written AbstractSessionEvent.java is the reference for this pattern.

2. Use record types for event data payloads

Every event variant's inner Data class must be generated as a Java record, not a mutable bean. For example, ToolExecutionStartEvent should contain:

@JsonIgnoreProperties(ignoreUnknown = true)
public record ToolExecutionStartData(
    @JsonProperty("toolCallId") String toolCallId,
    @JsonProperty("toolName") String toolName,
    @JsonProperty("arguments") Object arguments
) {}

Not:

public static class ToolExecutionStartData {
    private String toolCallId;
    public String getToolCallId() { return toolCallId; }
    public void setToolCallId(String toolCallId) { this.toolCallId = toolCallId; }
    // ...
}

Records are appropriate here because event data payloads are immutable value types deserialized from JSON — they are never constructed by SDK users or mutated after creation.

3. Use record types for RPC params and result classes

The RPC ...Params and ...Result classes generated from api.schema.json should also be records. These are request/response DTOs that are deserialized from JSON and not mutated.

4. Distinguish integer from number in type mapping

The current generator maps both "integer" and "number" to Double. This is incorrect.

• JSON Schema "integer" → Java Long (or Integer if the schema constrains the range, but default to Long)
• JSON Schema "number" → Java Double

Using floating point for integer values is dangerous and unacceptable. Fix schemaTypeToJava() to distinguish these cases.

5. Use primitive types for required fields, boxed types for optional

The required parameter is already computed in schemaTypeToJava() but not used to inform the Java type. Change this:

• Required boolean field → boolean (primitive)
• Optional boolean field → Boolean (boxed, nullable)
• Required integer field → long (primitive)
• Optional integer field → Long (boxed, nullable)
• Required number field → double (primitive)
• Optional number field → Double (boxed, nullable)

Note: this applies to mutable bean classes only. Records always use boxed types because record components are nullable by default and there is no way to distinguish "field absent from JSON" vs "field present with default value" with primitives.

6. Make event subclasses final

Every generated event variant class must be declared public final class ...Event extends SessionEvent. This cooperates with the sealed hierarchy and prevents accidental subclassing.

7. Reduce fallback to Object

The current generator falls back to Object for:

• Multi-type anyOf unions with more than one non-null branch
• Unrecognized schema patterns
• Untyped schemas

For each fallback site, add a console.warn() logging the schema path and context so that silent type erasure is visible during generation. Do not silently swallow schema information.

Additionally, for anyOf unions of exactly two concrete types where one is string, prefer String over Object — strings are the most common wire-level fallback.

8. Remove dead code

The function generateDataClass (around line 215) appears to be unused — it is not called from generateSessionEvents, generateRpcTypes, or main. Verify this claim:

• Search for all call sites of generateDataClass in java.ts and any other files in scripts/codegen/.
• If truly dead, remove it entirely.
• If it is used, fix its return type (currently returns an object but is typed as returning string, cast via as any).

9. Improve enum generation

Current enums use @JsonValue on a getValue() method but lack @JsonCreator for deserialization. Add a static @JsonCreator factory method to each generated enum:

@JsonCreator
public static MyEnum fromValue(String value) {
    for (MyEnum v : values()) {
        if (v.value.equals(value)) return v;
    }
    throw new IllegalArgumentException("Unknown value: " + value);
}

10. Generate Javadoc

• Each generated class must have a Javadoc comment. If the schema provides a description, use it. Otherwise, generate a sensible default (e.g., /** The {@code session.idle} session event. */).
• Each record component or field with a schema description must have a Javadoc comment.
• Add @since tags based on the current SDK version.

11. Add @JsonInclude(NON_NULL) consistently

The hand-written records use @JsonInclude(JsonInclude.Include.NON_NULL) at the class level. The generated code should do the same on all generated types.

Constraints

• Do not modify any hand-written files in src/main/java/. This task is only about improving the generator.
• Do not change the output directory (src/generated/java/com/github/copilot/sdk/generated/).
• Do not change the package name (com.github.copilot.sdk.generated).
• After making changes, run the generator and verify the output compiles: cd scripts/codegen && npm ci && npx tsx java.ts && cd ../.. && mvn compile -pl .
• Run mvn spotless:apply before committing.
• The generated code must be compatible with Java 17 (the project baseline).
• Jackson 2.x must be able to deserialize the generated records and sealed class hierarchy correctly. Test this by running mvn verify.

Verification checklist

After completing the changes, verify:

• SessionEvent.java is sealed with a permits clause listing all event classes plus UnknownSessionEvent
• All event ...Data inner classes are record types
• All RPC ...Params and ...Result classes are record types
• "integer" schema type maps to Long, "number" maps to Double
• Required primitive fields use unboxed types in mutable classes
• All event subclasses are public final class
• generateDataClass is removed (or fixed if actually used)
• Enums have @JsonCreator factory methods
• No silent Object fallbacks — each one logs a warning during generation
• mvn verify passes with all existing tests
• mvn spotless:apply produces no changes after a clean generation

@copilot

Epic #69, Chunk 1: Replace com.github.copilot.sdk.events with com.github.copilot.sdk.generated

Context

The Java SDK has two parallel sets of session event classes:

• Old (hand-written): com.github.copilot.sdk.events — 59 files including AbstractSessionEvent (sealed base), 57 *Event subclasses, UnknownSessionEvent, SessionEventParser, and package-info.java.
• New (generated): com.github.copilot.sdk.generated — 75+ files including SessionEvent (sealed base with @JsonTypeInfo/@JsonSubTypes), 74 *Event subclasses, and UnknownSessionEvent.

The generated package is a strict superset of the old package. It covers all 57 old event types plus ~18 new event types from the latest schema. The generated code uses Jackson-native polymorphic deserialization (@JsonTypeInfo/@JsonSubTypes on the base class with defaultImpl = UnknownSessionEvent.class) instead of the manual SessionEventParser type-map.

This chunk migrates the SDK from the old events package to the generated events package, then deletes the old package entirely.

Scope

✅ Change all import com.github.copilot.sdk.events.* → import com.github.copilot.sdk.generated.*
✅ Rename type references: AbstractSessionEvent → SessionEvent
✅ Rename inner record type references: FooData → FooEventData (e.g. AssistantMessageData → AssistantMessageEventData)
✅ Rename nested record type references (e.g. ToolRequest → AssistantMessageEventDataToolRequestsItem)
✅ Replace SessionEventParser.parse() calls with direct Jackson ObjectMapper.readValue(json, SessionEvent.class)
✅ Delete the entire src/main/java/com/github/copilot/sdk/events/ directory
✅✅ Update existing tests and generate new tests to cover the code you are creating and/or changing.

❌ Do NOT modify the com.github.copilot.sdk.json package — it is unrelated to this chunk.
❌ Do NOT modify the com.github.copilot.sdk.generated.rpc package — it is unrelated to this chunk.
❌ Do NOT modify the generator (scripts/codegen/java.ts) — this chunk is about wiring, not generation.
❌ Do NOT add new public API methods or change method signatures beyond what is required for the type rename.

Reference files to read first

Before making any changes, MUST read and understand these files:

• src/generated/java/com/github/copilot/sdk/generated/SessionEvent.java — the generated sealed base class with @JsonTypeInfo/@JsonSubTypes
• src/generated/java/com/github/copilot/sdk/generated/UnknownSessionEvent.java — the generated forward-compatibility fallback
• src/generated/java/com/github/copilot/sdk/generated/AssistantMessageEvent.java — example generated event (note inner record is AssistantMessageEventData, not AssistantMessageData)
• src/main/java/com/github/copilot/sdk/events/AbstractSessionEvent.java — the OLD base class being replaced
• src/main/java/com/github/copilot/sdk/events/SessionEventParser.java — the OLD manual type-map being eliminated
• src/main/java/com/github/copilot/sdk/CopilotSession.java — primary consumer (36 event imports, Set<Consumer<AbstractSessionEvent>>, on() methods, dispatchEvent(), getMessages())
• src/main/java/com/github/copilot/sdk/RpcHandlerDispatcher.java — uses AbstractSessionEvent and SessionEventParser.parse()
• src/main/java/com/github/copilot/sdk/EventErrorHandler.java — uses AbstractSessionEvent
• src/main/java/com/github/copilot/sdk/json/ResumeSessionConfig.java — references AbstractSessionEvent
• src/main/java/com/github/copilot/sdk/json/SessionConfig.java — references AbstractSessionEvent

Also read .github/copilot-instructions.md for project conventions.

Detailed migration steps

Step 1: Inventory all consumers

Run this to find every file that imports from the old events package:

grep -rl "import com.github.copilot.sdk.events" src/

MUST process every file found. Expected consumers:

Main source (5 files):

• CopilotSession.java — heaviest consumer (~36 imports)
• RpcHandlerDispatcher.java — uses AbstractSessionEvent, SessionEventParser.parse()
• EventErrorHandler.java — uses AbstractSessionEvent
• ResumeSessionConfig.java (in json package) — references AbstractSessionEvent
• SessionConfig.java (in json package) — references AbstractSessionEvent

Test source (~17+ files):

• SessionEventParserTest.java, CopilotSessionTest.java, SessionEventsE2ETest.java, ForwardCompatibilityTest.java, StreamingFidelityTest.java, ErrorHandlingTest.java, CompactionTest.java, and others.

Step 2: Replace base class references

In every consumer file:

MUST update all usages including:

• Field declarations: Set<Consumer<AbstractSessionEvent>> → Set<Consumer<SessionEvent>>
• Method signatures: Consumer<AbstractSessionEvent> → Consumer<SessionEvent>
• Type parameters: Class<T extends AbstractSessionEvent> → Class<T extends SessionEvent>
• Return types: List<AbstractSessionEvent> → List<SessionEvent>
• instanceof checks
• Cast expressions

Step 3: Replace event subclass imports

For each specific event class imported (e.g. AssistantMessageEvent, SessionIdleEvent):

Step 4: Rename inner record type references

The generated events use a different naming convention for inner data records:

MUST search for all references to old inner record names and rename them. Most code uses event.getData() without naming the inner type, so the impact should be limited.

Also rename nested types:

Step 5: Eliminate SessionEventParser

The generated SessionEvent base class has @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type", defaultImpl = UnknownSessionEvent.class) which means Jackson handles polymorphic deserialization natively.

MUST find all call sites of SessionEventParser.parse() and replace them:

The ObjectMapper MUST be configured with JavaTimeModule and FAIL_ON_UNKNOWN_PROPERTIES = false (same as the existing SessionEventParser uses internally).

Expected call sites:

• CopilotSession.java — in dispatchEvent() or message parsing
• RpcHandlerDispatcher.java — in event dispatching

MUST also remove the import of SessionEventParser from these files.

Step 6: Handle cross-package references

Two files in the json package reference the old events package:

• src/main/java/com/github/copilot/sdk/json/SessionConfig.java — references AbstractSessionEvent (in the onEvent consumer field)
• src/main/java/com/github/copilot/sdk/json/ResumeSessionConfig.java — references AbstractSessionEvent

MUST update these to import com.github.copilot.sdk.generated.SessionEvent instead and rename the type reference.

Additionally, two old event classes reference json package types:

• events.PermissionRequestedEvent → references json.PermissionRequest
• events.SessionContextChangedEvent → references json.SessionContext

Since these old classes are being deleted (replaced by generated equivalents that define their own inline data records), these cross-references vanish automatically. No action needed — just verify the generated replacements don't import from json.

Step 7: Delete the old events package

After all consumers are migrated:

git rm -r src/main/java/com/github/copilot/sdk/events/

MUST delete the entire directory. Every file in it is either replaced or obsolete:

• AbstractSessionEvent.java → replaced by generated.SessionEvent
• 57 *Event.java files → replaced by 74 generated *Event.java files
• UnknownSessionEvent.java → replaced by generated.UnknownSessionEvent
• SessionEventParser.java → eliminated (Jackson handles polymorphism)
• package-info.java → no longer needed

Step 8: Update and create tests

✅✅ Update existing tests and generate new tests to cover the code you are creating and/or changing.

Specifically:

• MUST update SessionEventParserTest.java to test Jackson-native deserialization via SessionEvent.class instead of SessionEventParser.parse(). Rename it to something like SessionEventDeserializationTest.java.
• MUST update all test files that import from com.github.copilot.sdk.events to import from com.github.copilot.sdk.generated instead.
• MUST verify UnknownSessionEvent fallback works: deserializing a JSON event with an unknown type string MUST produce an UnknownSessionEvent instance, not throw.
• MUST verify at least 5 representative event types round-trip through Jackson correctly (serialize → deserialize → assert fields match).
• MUST verify the sealed hierarchy: SessionEvent MUST be sealed, each subclass MUST be final.

Constraints

• MUST run mvn spotless:apply before committing.
• MUST run mvn verify and all tests MUST pass.
• MUST NOT leave any references to com.github.copilot.sdk.events anywhere in the codebase after this chunk is complete.
• MUST NOT change any generated files in src/generated/java/ — those are auto-generated and should not be hand-edited.
• MUST NOT add any new public API methods beyond what already exists.
• The generated code targets Java 17 (the project baseline).

Verification checklist

After completing the changes, verify and mark each item:

• grep -rl "com.github.copilot.sdk.events" src/ returns zero results
• src/main/java/com/github/copilot/sdk/events/ directory does not exist
• SessionEventParser.java does not exist anywhere
• CopilotSession.java uses SessionEvent (generated), not AbstractSessionEvent
• RpcHandlerDispatcher.java uses Jackson-native deserialization, not SessionEventParser.parse()
• SessionConfig.java references com.github.copilot.sdk.generated.SessionEvent, not AbstractSessionEvent
• ResumeSessionConfig.java references com.github.copilot.sdk.generated.SessionEvent, not AbstractSessionEvent
• Unknown event types deserialize to UnknownSessionEvent (test exists and passes)
• At least 5 event types round-trip through Jackson correctly (tests exist and pass)
• mvn spotless:apply produces no changes
• mvn verify passes — all tests green, zero failures

@copilot The most recent test run had failures. Fix the failures and push additional commits.

@copilot

Read and execute these instructions.

Epic #69, Chunk 3: Wire the Generated RPC Wrappers into the SDK

Context

After chunk 2, the Java SDK has generated ServerRpc and SessionRpc classes in com.github.copilot.sdk.generated.rpc with typed methods for all ~50 RPC methods defined in api.schema.json. However, these wrappers are still not connected to the SDK — nothing instantiates or calls them.

The reference SDKs in copilot-sdk expose these wrappers as public properties:

• .NET: CopilotClient has public ServerRpc Rpc { get; } and CopilotSession has public SessionRpc Rpc { get; }.
• Node: CopilotClient has get rpc() returning createServerRpc(connection) and CopilotSession has get rpc() returning createSessionRpc(connection, sessionId).

The .NET and Node SDKs also route 8 of their internal RPC calls through the generated wrappers instead of calling InvokeRpcAsync/sendRequest directly. The remaining ~43 generated methods are available to end users through the public Rpc property.

This chunk wires the generated wrappers into the Java SDK, matching the reference implementation pattern.

Scope

✅ Add a public ServerRpc getRpc() method to CopilotClient
✅ Add a public SessionRpc getRpc() method to CopilotSession
✅ Migrate internal RPC call sites to use the generated typed wrappers (the 8 methods the reference SDKs route through wrappers)
✅ Expose the full generated RPC API surface to end users
✅✅ Update existing tests and generate new tests to cover the code you are creating and/or changing.

❌ Do NOT modify the generator (scripts/codegen/java.ts) — this chunk is about wiring, not generation.
❌ Do NOT modify the generated files in src/generated/java/ — those are auto-generated.
❌ Do NOT remove the com.github.copilot.sdk.json package — it contains public API types that are still needed.
❌ Do NOT remove hand-written lifecycle methods (createSession, resumeSession, send, getMessages, abort, etc.) — these use RPC methods not in api.schema.json (the "schema gap").
❌ Do NOT break any existing public API signatures.

Reference files to read first

Before making any changes, MUST read and understand these files:

Java SDK files to modify:

• src/main/java/com/github/copilot/sdk/CopilotClient.java — will get ServerRpc getRpc()
• src/main/java/com/github/copilot/sdk/CopilotSession.java — will get SessionRpc getRpc() and internal call site migrations
• src/main/java/com/github/copilot/sdk/JsonRpcClient.java — the underlying RPC client the wrappers call

Generated wrappers (from chunk 2):

• src/generated/java/com/github/copilot/sdk/generated/rpc/ServerRpc.java
• src/generated/java/com/github/copilot/sdk/generated/rpc/SessionRpc.java

Reference implementations (the gold standard):

• e:\workareas\copilot-sdk-00\dotnet\src\Client.cs — see how ServerRpc Rpc property is exposed (line ~92) and how _rpc is initialized (line ~1368)
• e:\workareas\copilot-sdk-00\dotnet\src\Session.cs — see how SessionRpc Rpc property is exposed (line ~92) and which internal calls route through it (lines ~484-1063)
• e:\workareas\copilot-sdk-00\nodejs\src\client.ts — see how get rpc() is exposed (line ~252)
• e:\workareas\copilot-sdk-00\nodejs\src\session.ts — see how get rpc() is exposed (line ~117) and which calls route through it (lines ~484-1063)

Also read .github/copilot-instructions.md for project conventions.

Detailed migration steps

Step 1: Add ServerRpc getRpc() to CopilotClient

MUST add a public method that returns the generated ServerRpc instance:

import com.github.copilot.sdk.generated.rpc.ServerRpc;

// In CopilotClient:
private ServerRpc serverRpc;

/**
 * Returns the typed RPC client for server-scoped methods.
 *
 * <p>The client must be started before calling this method.
 * Use {@link #start()} or set {@link CopilotClientOptions#setAutoStart(boolean)} to true.</p>
 *
 * @return the server RPC client
 * @throws IllegalStateException if the client is not started
 */
public ServerRpc getRpc() {
    if (serverRpc == null) {
        throw new IllegalStateException("Client is not started. Call start() first.");
    }
    return serverRpc;
}

MUST initialize serverRpc when the connection is established (in the same place where the JsonRpcClient is created/connected).

Step 2: Add SessionRpc getRpc() to CopilotSession

MUST add a public method that returns the generated SessionRpc instance:

import com.github.copilot.sdk.generated.rpc.SessionRpc;

// In CopilotSession:
private SessionRpc sessionRpc;

/**
 * Returns the typed RPC client for session-scoped methods.
 *
 * @return the session RPC client
 */
public SessionRpc getRpc() {
    if (sessionRpc == null) {
        sessionRpc = new SessionRpc(rpc, sessionId);
    }
    return sessionRpc;
}

MUST use lazy initialization (matching the .NET ??= pattern and Node's lazy get rpc() getter).

Step 3: Migrate internal call sites to use generated wrappers

The reference SDKs route these 8 RPC methods through the generated wrappers. MUST migrate the equivalent Java call sites:

For each migration:

• MUST construct the appropriate *Params record from the existing inline Map.of(...) or ad-hoc parameter objects.
• MUST use the *Result return type from the generated wrapper.
• MUST preserve existing error handling and CompletableFuture chaining.
• MUST verify the behavior is identical — same RPC method name, same parameters, same result handling.

Step 4: Do NOT migrate lifecycle methods

The following RPC methods are NOT in api.schema.json and therefore have no generated wrappers. MUST NOT attempt to migrate these:

• session.create — hand-written in CopilotClient
• session.resume — hand-written in CopilotClient
• session.send — hand-written in CopilotSession
• session.getMessages — hand-written in CopilotSession
• session.abort — hand-written in CopilotSession
• session.destroy — hand-written in CopilotSession
• session.delete — hand-written in CopilotClient
• session.list — hand-written in CopilotClient
• session.getMetadata — hand-written in CopilotClient
• session.getLastId — hand-written in CopilotClient
• session.getForeground — hand-written in CopilotClient
• session.setForeground — hand-written in CopilotClient
• ping — hand-written in CopilotClient (note: the generated ServerRpc also has ping() — both can coexist, matching .NET)
• status.get — hand-written in CopilotClient
• auth.getStatus — hand-written in CopilotClient
• models.list — hand-written in CopilotClient (same coexistence as ping)
• session.compaction.compact — hand-written in CopilotSession

These MUST continue using rpc.invoke() directly.

Step 5: Parameter adaptation

When migrating call sites, the existing code often constructs parameters as Map.of("sessionId", sessionId, "requestId", requestId, ...). The generated wrappers expect *Params record instances instead.

MUST construct the correct *Params record for each migrated call site. For example:

// OLD:
rpc.invoke("session.tools.handlePendingToolCall",
    Map.of("sessionId", sessionId, "requestId", requestId, "result", result),
    Void.class);

// NEW:
getRpc().getTools().handlePendingToolCall(
    new SessionToolsHandlePendingToolCallParams(sessionId, requestId, result));

MUST verify that the *Params record fields match the parameters currently being passed.

Step 6: Write tests

✅✅ Update existing tests and generate new tests to cover the code you are creating and/or changing.

Specifically:

• MUST add tests verifying CopilotClient.getRpc() returns a valid ServerRpc instance after start
• MUST add tests verifying CopilotClient.getRpc() throws IllegalStateException before start
• MUST add tests verifying CopilotSession.getRpc() returns a valid SessionRpc instance
• MUST add tests verifying the migrated call sites still produce the correct RPC invocations (method name, parameters)
• MUST update any existing tests that mock or verify the migrated rpc.invoke() calls to match the new pattern

Constraints

• MUST run mvn spotless:apply before committing.
• MUST run mvn verify and all tests MUST pass.
• MUST NOT break any existing public API — this is purely additive (new getRpc() methods) plus internal refactoring.
• MUST NOT remove any existing public methods on CopilotClient or CopilotSession — the hand-written convenience methods (e.g., listModels(), ping(), setModel(), log()) MUST continue to exist alongside the generated getRpc() API, matching the .NET pattern where both coexist.
• MUST NOT modify any generated files in src/generated/java/.
• The generated code targets Java 17.

Verification checklist

After completing the changes, verify and mark each item:

• CopilotClient has a public ServerRpc getRpc() method
• CopilotSession has a public SessionRpc getRpc() method
• CopilotClient.getRpc() throws IllegalStateException when client is not started
• CopilotSession.getRpc() returns a lazily-initialized SessionRpc
• session.model.switchTo call site uses getRpc().getModel().switchTo()
• session.tools.handlePendingToolCall call sites use getRpc().getTools().handlePendingToolCall()
• session.permissions.handlePendingPermissionRequest call sites use getRpc().getPermissions().handlePendingPermissionRequest()
• session.commands.handlePendingCommand call sites use getRpc().getCommands().handlePendingCommand()
• session.ui.elicitation call sites use getRpc().getUi().elicitation()
• session.ui.handlePendingElicitation call sites use getRpc().getUi().handlePendingElicitation()
• session.log call sites use getRpc().log()
• sessionFs.setProvider call site uses getRpc().getSessionFs().setProvider()
• Hand-written lifecycle methods (createSession, resumeSession, send, getMessages, abort, etc.) still use rpc.invoke() directly — NOT migrated
• Existing convenience methods (ping(), listModels(), setModel(), log(), etc.) still exist and work
• New tests exist for getRpc() on both CopilotClient and CopilotSession
• Migrated call sites have test coverage verifying correct RPC method names and parameters
• mvn spotless:apply produces no changes
• mvn verify passes — all tests green, zero failures

@copilot Consider this "report card" grading your work in commit a2712a7 . It's a bad report card.

I need at least a "B" for all rows in this table. Many of them are "F".

Please closely analyze this report card, making fixes and running mvn clean verify and getting a clean run before saying the work is ready for my review.

After you are done, I will generate another report card and hopefully I'll see all grades of at least "B". Ideally I want to see straight "A"s!

I know you can do it! You have the know-how the authority!

Report Card: Epic #69, Chunk 3 (Wire Generated RPC Wrappers Into SDK)

Overall Grade: C-

Findings (ordered by severity)

1. Major scope miss: 6 of the 8 required internal RPC migrations are still using direct rpc.invoke calls.

• Tool call handling is still direct invoke in CopilotSession.java, CopilotSession.java, CopilotSession.java
• UI pending elicitation handler is still direct invoke in CopilotSession.java, CopilotSession.java, CopilotSession.java
• UI elicitation API methods still call direct invoke in CopilotSession.java, CopilotSession.java, CopilotSession.java, CopilotSession.java
• Session model switch is still direct invoke in CopilotSession.java
• Session log is still direct invoke in CopilotSession.java
• I found no internal sessionFs.setProvider wiring in client code; only generated API exists in ServerSessionFsApi.java

2. Session getRpc behavior does not match rubric’s lazy-init requirement.

• getRpc returns a field directly in CopilotSession.java
• SessionRpc is eagerly constructed in constructors/setter in CopilotSession.java, CopilotSession.java

3. Migration is inconsistent: permissions path is only partially moved to wrappers.

• Still direct invoke on success path in CopilotSession.java
• Wrapper used on error paths in CopilotSession.java, CopilotSession.java

4. Test coverage required by rubric is incomplete.

• Session getRpc tests exist in RpcWrappersTest.java and CopilotSessionTest.java
• I found no CopilotClient.getRpc before/after start tests in CopilotClientTest.java
• I found no tests validating migrated internal call sites for method name plus params, beyond standalone generated wrapper behavior tests in RpcWrappersTest.java

Rubric Scoring

Open Questions / Assumptions

1. Was sessionFs.setProvider intentionally removed from handwritten client flows before this chunk? If yes, rubric should mark that item as not applicable; if no, it is missing work.
2. Should getRpc in session be truly lazy per rubric, or is eager caching acceptable for this codebase? Current implementation conflicts with rubric wording.

Short Summary

The branch adds public RPC access points and part of the session-side migration, but it does not complete the core chunk goal of routing the specified internal calls through generated wrappers. The biggest grade reducers are incomplete migration coverage, non-lazy session getRpc, and missing required client/getRpc and migrated-callsite tests.

@copilot

Now that we have completed the transition to using code generation implemented in the last 14 commits on this topic branch, it is time to modify the agentic workflow that syncs with the reference implementations so that the LLM does not modify the generated code.

The correct way to modify the generated code is to get the necessary changes made in the "@github/copilot@$VERSION" npm artifact, and then re-run the update-copilot-dependency.yml workflow.

The file agentic-merge-reference-impl.prompt.md is the key part of the mechanism that synchronizes the Java SDK with the dotnet and nodejs reference implementations.

Please modify this file, and any other parts of the mechanism, so that code in src/generated/java is ❌❌❌NEVER MODIFIED BY THE AGENTIC WORKFLOW❌❌❌. These files are forbidden.

Be very emphatic. Use lots of all caps and ❌ characters.

Put this guidance in the correct place.

If the agentic sync cannot be completed without touching the forbidden files, fail the agentic sync and include a message explaining what happened. Suggest that the update-copilot-dependency.yml may need to be re-run.